home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / etc / RCS / option.c,v < prev    next >
Text File  |  1991-01-28  |  17KB  |  765 lines
  1. head     1.9;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.9
  10. date     91.01.28.16.44.36;  author kupfer;  state Exp;
  11. branches ;
  12. next     1.8;
  13.  
  14. 1.8
  15. date     91.01.28.12.33.44;  author kupfer;  state Exp;
  16. branches ;
  17. next     1.7;
  18.  
  19. 1.7
  20. date     89.01.02.13.55.49;  author douglis;  state Exp;
  21. branches ;
  22. next     1.6;
  23.  
  24. 1.6
  25. date     88.09.13.10.23.05;  author douglis;  state Exp;
  26. branches ;
  27. next     1.5;
  28.  
  29. 1.5
  30. date     88.08.05.15.47.19;  author ouster;  state Exp;
  31. branches ;
  32. next     1.4;
  33.  
  34. 1.4
  35. date     88.08.05.15.38.24;  author ouster;  state Exp;
  36. branches ;
  37. next     1.3;
  38.  
  39. 1.3
  40. date     88.08.04.08.35.52;  author ouster;  state Exp;
  41. branches ;
  42. next     1.2;
  43.  
  44. 1.2
  45. date     88.08.01.13.28.34;  author ouster;  state Exp;
  46. branches ;
  47. next     1.1;
  48.  
  49. 1.1
  50. date     88.08.01.10.42.22;  author ouster;  state Exp;
  51. branches ;
  52. next     ;
  53.  
  54.  
  55. desc
  56. @@
  57.  
  58.  
  59. 1.9
  60. log
  61. @Don't return a time if there is an error.
  62. @
  63. text
  64. @/*
  65.  * option.c --
  66.  *
  67.  *    Routines to do command line option processing.
  68.  *
  69.  * Copyright 1986, 1991 Regents of the University of California
  70.  * Permission to use, copy, modify, and distribute this
  71.  * software and its documentation for any purpose and without
  72.  * fee is hereby granted, provided that the above copyright
  73.  * notice appear in all copies.  The University of California
  74.  * makes no representations about the suitability of this
  75.  * software for any purpose.  It is provided "as is" without
  76.  * express or implied warranty.
  77.  */
  78.  
  79. #ifndef lint
  80. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/option.c,v 1.8 91/01/28 12:33:44 kupfer Exp Locker: kupfer $ SPRITE (Berkeley)";
  81. #endif not lint
  82.  
  83. #include <option.h>
  84. #include <cfuncproto.h>
  85. #include <stdio.h>
  86. #include <stdlib.h>
  87. #include <strings.h>
  88. #include <time.h>
  89.  
  90. #define OptNoArg(progName, opt) fprintf(stderr, \
  91.               "Warning: %s option \"-%s\" needs an argument\n", \
  92.               (progName), (opt))
  93.  
  94. /* Forward references: */
  95.  
  96. static void ParseTime _ARGS_ ((char *progName, char *str,
  97.                  time_t *resultPtr));
  98.  
  99.  
  100. /*
  101.  *----------------------------------------------------------------------
  102.  *
  103.  * Opt_Parse --
  104.  *
  105.  *    Process a command line according to a template of accepted
  106.  *    options.  See the manual page and header file for more details.
  107.  *
  108.  * Results:
  109.  *    The number of options that weren't processed by this procedure
  110.  *    is returned, and argv points to an array of unprocessed
  111.  *    options.  (This is all of the options that didn't start with
  112.  *    "-", except for those used as arguments to the options
  113.  *    processed here; it's also anything after an OPT_REST option.)
  114.  *
  115.  * Side effects:
  116.  *    The variables referenced from the option array get modified
  117.  *    if their option was present on the command line.  Can clobber 
  118.  *    the global buffer used by localtime(3).
  119.  *
  120.  *----------------------------------------------------------------------
  121.  */
  122.  
  123. int
  124. Opt_Parse(argc, argv, optionArray, numOptions, flags)
  125.     register int  argc;         /* Number of arguments in argv. */
  126.     char          **argv;           /* Array of arguments */
  127.     Option        optionArray[];    /* Array of option descriptions */
  128.     int              numOptions;        /* Size of optionArray */
  129.     int          flags;        /* Or'ed combination of various flag bits:
  130.                      * see option.h for definitions. */
  131. {
  132.     register Option     *optionPtr; /* pointer to the current option in the
  133.                      * array of option specifications */
  134.     register char     *curOpt;    /* Current flag argument */
  135.     register char     **curArg;   /* Current argument */
  136.     register int      argIndex;   /* Index into argv to which next unused
  137.                      * argument should be copied */
  138.     int           stop=0;        /* Set non-zero to stop processing
  139.                      * arguments when an OPT_REST flag is
  140.                      * encountered */
  141.     int            length;        /* Number of characters in current
  142.                      * option. */
  143.  
  144.     argIndex = 1;
  145.     argc -= 1;
  146.     curArg = &argv[1];
  147.  
  148.     while (argc && !stop) {
  149.     if (**curArg == '-') {
  150.         curOpt = &curArg[0][1];
  151.         curArg += 1;
  152.         argc -= 1;
  153.  
  154.         /*
  155.          * Check for the special options "?" and "help".  If found,
  156.          * print documentation and exit.
  157.          */
  158.  
  159.         if ((strcmp(curOpt, "?") == 0) || (strcmp(curOpt, "help") == 0)) {
  160.         Opt_PrintUsage (argv[0], optionArray, numOptions);
  161.         exit(0);
  162.         }
  163.  
  164.         /*
  165.          * Loop over all the options specified in a single argument
  166.          * (must be 1 unless OPT_ALLOW_CLUSTERING was specified).
  167.          */
  168.  
  169.         while (1) {
  170.         /*
  171.          * Loop over the array of options searching for one with the
  172.          * matching key string.  If found, it is left pointed to by
  173.          * optionPtr.
  174.          */
  175.         for (optionPtr = &optionArray[numOptions - 1];
  176.             optionPtr >= optionArray;
  177.             optionPtr -= 1) {
  178.              if (optionPtr->key == NULL) {
  179.              continue;
  180.              }
  181.              if (*optionPtr->key == *curOpt) {
  182.              if (flags & OPT_ALLOW_CLUSTERING) {
  183.                  length = strlen(optionPtr->key);
  184.                  if (strncmp(optionPtr->key, curOpt, length) == 0) {
  185.                  break;
  186.                  }
  187.              } else {
  188.                  if (strcmp(optionPtr->key, curOpt) == 0) {
  189.                  break;
  190.                  }
  191.              }
  192.              }
  193.         }
  194.  
  195.         if (optionPtr < optionArray) {
  196.             /*
  197.              * No match.  Print error message and skip option.
  198.              */
  199.  
  200.             fprintf(stderr, "Unknown option \"-%s\";", curOpt);
  201.             fprintf(stderr, "  type \"%s -help\" for information\n",
  202.                 argv[0]);
  203.             break;
  204.         }
  205.  
  206.         /*
  207.          * Take the appropriate action based on the option type
  208.          */
  209.  
  210.         if (optionPtr->type >= 0) {
  211.             *((int *) optionPtr->address) = optionPtr->type;
  212.         } else {
  213.             switch (optionPtr->type) {
  214.             case OPT_REST:
  215.                 stop = 1;
  216.                 *((int *) optionPtr->address) = argIndex;
  217.                 break;
  218.             case OPT_STRING:
  219.                 if (argc == 0) {
  220.                 OptNoArg(argv[0], optionPtr->key);
  221.                 } else {
  222.                 *((char **)optionPtr->address) = *curArg;
  223.                 curArg++;
  224.                 argc--;
  225.                 }
  226.                 break;
  227.             case OPT_INT:
  228.                 if (argc == 0) {
  229.                 OptNoArg(argv[0], optionPtr->key);
  230.                 } else {
  231.                 char *endPtr;
  232.  
  233.                 *((int *) optionPtr->address) =
  234.                     strtol(*curArg, &endPtr, 0);
  235.                 if (endPtr == *curArg) {
  236.                     fprintf(stderr,
  237.       "Warning: option \"-%s\" got a non-numeric argument \"%s\".  Setting to 0.\n",
  238.                         optionPtr->key, *curArg);
  239.                 }
  240.                 curArg++;
  241.                 argc--;
  242.                 }
  243.                 break;
  244.             case OPT_TIME:
  245.                 if (argc == 0) {
  246.                 OptNoArg(argv[0], optionPtr->key);
  247.                 } else {
  248.                 ParseTime(argv[0], *curArg, 
  249.                       (time_t *)optionPtr->address);
  250.                 curArg++;
  251.                 argc--;
  252.                 }
  253.                 break;
  254.             case OPT_FLOAT:
  255.                 if (argc == 0) {
  256.                 OptNoArg(argv[0], optionPtr->key);
  257.                 } else {
  258.                 char *endPtr;
  259.  
  260.                 *((double *) optionPtr->address) =
  261.                     strtod(*curArg, &endPtr);
  262.                 if (endPtr == *curArg) {
  263.                     fprintf(stderr,
  264.       "Warning: option \"-%s\" got non-floating-point argument \"%s\".  Setting to 0.\n",
  265.                         optionPtr->key, *curArg);
  266.                 }
  267.                 curArg++;
  268.                 argc--;
  269.                 }
  270.                 break;
  271.             case OPT_GENFUNC: {
  272.                 int        (*handlerProc)();
  273.  
  274.                 handlerProc = (int (*)())optionPtr->address;
  275.  
  276.                 argc = (* handlerProc) (optionPtr->key, argc,
  277.                     curArg);
  278.                 break;
  279.             }
  280.             case OPT_FUNC: {
  281.                 int (*handlerProc)();
  282.  
  283.                 handlerProc = (int (*)())optionPtr->address;
  284.                 
  285.                 if ((* handlerProc) (optionPtr->key, *curArg)) {
  286.                 curArg += 1;
  287.                 argc -= 1;
  288.                 }
  289.                 break;
  290.             }
  291.             case OPT_DOC:
  292.                 Opt_PrintUsage (argv[0], optionArray, numOptions);
  293.                 exit(0);
  294.                 /*NOTREACHED*/
  295.             }
  296.         }
  297.         /*
  298.          * Advance to next option
  299.          */
  300.  
  301.         if (flags & OPT_ALLOW_CLUSTERING) {
  302.             curOpt += length;
  303.             if (*curOpt == 0) {
  304.             break;
  305.             }
  306.         } else {
  307.             break;
  308.         }
  309.         }
  310.     } else {
  311.         /*
  312.          * *curArg is an argument for which we have no use, so copy it
  313.          * down.
  314.          */
  315.         argv[argIndex] = *curArg;
  316.         argIndex += 1;
  317.         curArg += 1;
  318.         argc -= 1;
  319.  
  320.         /*
  321.          * If this wasn't an option, and we're supposed to stop parsing
  322.          * the first time we see something other than "-", quit.
  323.          */
  324.         if (flags & OPT_OPTIONS_FIRST) {
  325.         stop = 1;
  326.         }
  327.     }
  328.     }
  329.  
  330.     /*
  331.      * If we broke out of the loop because of an OPT_REST argument, we want
  332.      * to copy the rest of the arguments down, so we do.
  333.      */
  334.     while (argc) {
  335.     argv[argIndex] = *curArg;
  336.     argIndex += 1;
  337.     curArg += 1;
  338.     argc -= 1;
  339.     }
  340.     argv[argIndex] = (char *)NULL;
  341.     return argIndex;
  342. }
  343.  
  344.  
  345. /*
  346.  *----------------------------------------------------------------------
  347.  *
  348.  * Opt_PrintUsage --
  349.  *
  350.  *    Print out a usage message for a command.  This prints out the
  351.  *    documentation strings associated with each option.
  352.  *
  353.  * Results:
  354.  *    none.
  355.  *
  356.  * Side effects:
  357.  *    Messages printed onto the console.
  358.  *
  359.  *----------------------------------------------------------------------
  360.  */
  361.  
  362. void
  363. Opt_PrintUsage(commandName, optionArray, numOptions)
  364.     char *commandName;
  365.     Option optionArray[];
  366.     int numOptions;
  367. {
  368.     register int i;
  369.     int width;
  370.  
  371.     /*
  372.      * First, compute the width of the widest option key, so that we
  373.      * can make everything line up.
  374.      */
  375.  
  376.     width = 4;
  377.     for (i=0; i<numOptions; i++) {
  378.     int length;
  379.     if (optionArray[i].key == NULL) {
  380.         continue;
  381.     }
  382.     length = strlen(optionArray[i].key);
  383.     if (length > width) {
  384.         width = length;
  385.     }
  386.     }
  387.  
  388.     fprintf(stderr, "Usage of command \"%s\"\n", commandName);
  389.     for (i=0; i<numOptions; i++) {
  390.     if (optionArray[i].type != OPT_DOC) {
  391.         fprintf(stderr, " -%s%-*s %s\n", optionArray[i].key,
  392.             width+1-strlen(optionArray[i].key), ":",
  393.             optionArray[i].docMsg);
  394.         switch (optionArray[i].type) {
  395.         case OPT_INT: {
  396.             fprintf(stderr, "\t\tDefault value: %d\n",
  397.                 *((int *) optionArray[i].address));
  398.             break;
  399.         }
  400.         case OPT_FLOAT: {
  401.             fprintf(stderr, "\t\tDefault value: %lg\n",
  402.                 *((double *) optionArray[i].address));
  403.             break;
  404.         }
  405.         case OPT_STRING: {
  406.             if (*(char **)optionArray[i].address != (char *) NULL) {
  407.                 fprintf(stderr, "\t\tDefault value: \"%s\"\n",
  408.                     *(char **) optionArray[i].address);
  409.                 break;
  410.             }
  411.         }
  412.         default: {
  413.             break;
  414.         }
  415.         }
  416.     } else {
  417.         fprintf(stderr, " %s\n", optionArray[i].docMsg);
  418.     }
  419.     }
  420.     fprintf(stderr, " -help%-*s Print this message\n", width-3, ":");
  421. }
  422.  
  423.  
  424. /*
  425.  *----------------------------------------------------------------------
  426.  *
  427.  * ParseTime --
  428.  *
  429.  *    Convert a date and time from some string representation to 
  430.  *    something we can compute with.
  431.  *
  432.  * Results:
  433.  *    If str points to a parsable time, the corresponding UNIX time 
  434.  *    value (seconds past the epoch) is returned through resultPtr.
  435.  *
  436.  * Side effects:
  437.  *    Can clobber the global buffer used by localtime(3).
  438.  *
  439.  *----------------------------------------------------------------------
  440.  */
  441.  
  442. static void
  443. ParseTime(progName, str, resultPtr)
  444.     char    *progName;    /* name that the program was called as */
  445.     char    *str;        /* the string to parse */
  446.     time_t    *resultPtr;    /* pointer to result time value */
  447. {
  448.     long result;        /* the answer */
  449.     char *endPtr;        /* pointer into str, for parsing */
  450.     struct tm pieces;        /* year, month, etc. as integers */
  451.  
  452.     /* 
  453.      * We currently accept the following formats:
  454.      * 
  455.      * (1) an integer number of seconds past the epoch.
  456.      * (2) a string of the form "yy.mm.dd.hh.mm.ss"
  457.      */
  458.     
  459.     result = strtol(str, &endPtr, 0);
  460.     if (endPtr == str) {
  461.     goto parseError;
  462.     }
  463.     if (*endPtr == '\0') {
  464.     *resultPtr = result;
  465.     return;
  466.     }
  467.  
  468.     /* 
  469.      * Not a simple integer, so try form 2. 
  470.      */
  471.     if (*endPtr != '.') {
  472.     goto parseError;
  473.     }
  474.     pieces.tm_year = result;
  475.     if (pieces.tm_year > 1900) {
  476.     pieces.tm_year -= 1900;
  477.     }
  478.     pieces.tm_mon = strtol(endPtr+1, &endPtr, 0) - 1;
  479.     if (endPtr == str || *endPtr != '.') {
  480.     goto parseError;
  481.     }
  482.     pieces.tm_mday = strtol(endPtr+1, &endPtr, 0);
  483.     if (endPtr == str || *endPtr != '.') {
  484.     goto parseError;
  485.     }
  486.     pieces.tm_hour = strtol(endPtr+1, &endPtr, 0);
  487.     if (endPtr == str || *endPtr != '.') {
  488.     goto parseError;
  489.     }
  490.     pieces.tm_min = strtol(endPtr+1, &endPtr, 0);
  491.     if (endPtr == str || *endPtr != '.') {
  492.     goto parseError;
  493.     }
  494.     pieces.tm_sec = strtol(endPtr+1, &endPtr, 0);
  495.     if (endPtr == str || *endPtr != '\0') {
  496.     goto parseError;
  497.     }
  498.  
  499.     result = mktime(&pieces);
  500.     if (result == -1) {
  501.     fprintf(stderr, "%s: can't represent the time \"%s\".\n",
  502.         progName, str);
  503.     } else {
  504.     *resultPtr = result;
  505.     }
  506.     return;
  507.  
  508.  parseError:
  509.     fprintf(stderr, "%s: can't parse \"%s\" as a time.\n", progName, str);
  510.     return;
  511. }
  512. @
  513.  
  514.  
  515. 1.8
  516. log
  517. @Add OPT_TIME flavor.
  518. @
  519. text
  520. @d17 1
  521. a17 1
  522. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/option.c,v 1.7 89/01/02 13:55:49 douglis Exp Locker: kupfer $ SPRITE (Berkeley)";
  523. d33 2
  524. a34 1
  525. static time_t ParseTime _ARGS_ ((char *progName, char *str));
  526. d185 2
  527. a186 2
  528.                 *((time_t *) optionPtr->address) =
  529.                     ParseTime(argv[0], *curArg);
  530. d370 2
  531. a371 1
  532.  *    Returns the UNIX time value (seconds past the epoch).
  533. d379 5
  534. a383 4
  535. static time_t
  536. ParseTime(progName, str)
  537.     char *progName;        /* name that the program was called as */
  538.     char *str;            /* the string to parse */
  539. d401 2
  540. a402 1
  541.     return (time_t)result;
  542. d405 3
  543. a407 1
  544.     /* Try form 2. */
  545. d440 2
  546. a441 1
  547.     result = 0;
  548. d443 1
  549. a443 2
  550.  
  551.     return (time_t)result;
  552. d447 1
  553. a447 1
  554.     return (time_t)0;
  555. @
  556.  
  557.  
  558. 1.7
  559. log
  560. @if OPT_OPTIONS_FIRST option specified, and we hit something other than
  561. "-", stop parsing.
  562. @
  563. text
  564. @d6 1
  565. a6 1
  566.  * Copyright 1986 Regents of the University of California
  567. d17 1
  568. a17 1
  569. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/option.c,v 1.6 88/09/13 10:23:05 douglis Exp Locker: douglis $ SPRITE (Berkeley)";
  570. d21 1
  571. d25 1
  572. d30 5
  573. d53 2
  574. a54 1
  575.  *    if their option was present on the command line.
  576. d180 10
  577. d279 1
  578. d357 85
  579. @
  580.  
  581.  
  582. 1.6
  583. log
  584. @changed header for Opt_Parse to reflect real return value.
  585. @
  586. text
  587. @d17 1
  588. a17 1
  589. static char rcsid[] = "$Header: option.c,v 1.5 88/08/05 15:47:19 ouster Exp $ SPRITE (Berkeley)";
  590. d58 1
  591. a58 2
  592.                      * only OPT_ALLOW_CLUSTERING is currently
  593.                      * defined. */
  594. d237 8
  595. @
  596.  
  597.  
  598. 1.5
  599. log
  600. @Better help information.
  601. @
  602. text
  603. @d17 1
  604. a17 1
  605. static char rcsid[] = "$Header: option.c,v 1.4 88/08/05 15:38:24 ouster Exp $ SPRITE (Berkeley)";
  606. d38 5
  607. a42 5
  608.  *    There is no return result.  However, argv and *argcPtr are
  609.  *    modified to describe just the options that weren't processed by
  610.  *    this procedure (this is all of the options that didn't start
  611.  *    with "-", except for those used as arguments to the options
  612.  *    processed here;  it's also anything after an OPT_REST option).
  613. @
  614.  
  615.  
  616. 1.4
  617. log
  618. @Be careful to use correct option name in error messages and other things.
  619. @
  620. text
  621. @d17 1
  622. a17 1
  623. static char rcsid[] = "$Header: option.c,v 1.3 88/08/04 08:35:52 ouster Exp $ SPRITE (Berkeley)";
  624. d129 3
  625. a131 1
  626.             fprintf(stderr, "Unknown option \"-%s\"\n", curOpt);
  627. d286 1
  628. a286 1
  629.     width = 0;
  630. d330 1
  631. @
  632.  
  633.  
  634. 1.3
  635. log
  636. @Added "-help" option, changed allowClustering to flags.
  637. @
  638. text
  639. @d17 1
  640. a17 1
  641. static char rcsid[] = "$Header: option.c,v 1.2 88/08/01 13:28:34 ouster Exp $ SPRITE (Berkeley)";
  642. d147 1
  643. a147 1
  644.                 OptNoArg(argv[0], curOpt);
  645. d156 1
  646. a156 1
  647.                 OptNoArg(argv[0], curOpt);
  648. d165 1
  649. a165 1
  650.                         curOpt, *curArg);
  651. d173 1
  652. a173 1
  653.                 OptNoArg(argv[0], curOpt);
  654. d182 1
  655. a182 1
  656.                         curOpt, *curArg);
  657. d193 2
  658. a194 1
  659.                 argc = (* handlerProc) (curOpt, argc, curArg);
  660. d202 1
  661. a202 1
  662.                 if ((* handlerProc) (curOpt, *curArg)) {
  663. @
  664.  
  665.  
  666. 1.2
  667. log
  668. @Handle NULL keys.
  669. @
  670. text
  671. @d17 1
  672. a17 1
  673. static char rcsid[] = "$Header: option.c,v 1.1 88/08/01 10:42:22 ouster Exp $ SPRITE (Berkeley)";
  674. d25 3
  675. a27 3
  676. #define OptNoArg(chr) fprintf(stderr, \
  677.               "Warning: option \"-%s\" needs an argument\n", \
  678.               (chr))
  679. d52 2
  680. a53 2
  681. Opt_Parse(argc, argv, optionArray, numOptions, allowClustering)
  682.     int           argc;         /* Number of arguments in argv. */
  683. d57 3
  684. a59 5
  685.     int          allowClustering;  /* Non-zero means several options may
  686.                      * be grouped together with a single "-",
  687.                      * e.g. "foo -abc" instead of
  688.                      * "foo -a -b -c".  This only makes sense
  689.                      * if all options are single letters. */
  690. a64 1
  691.     register int      argc;        /* Count of remaining arguments */
  692. d84 10
  693. d95 1
  694. a95 1
  695.          * (must be 1 unless allowClustering is TRUE).
  696. d111 1
  697. a111 1
  698.              if (allowClustering) {
  699. d126 1
  700. a126 3
  701.              * No match.  Check for "?".  If found, print documentation
  702.              * and exit.  Otherwise print error message and skip
  703.              * option.
  704. a128 4
  705.             if (strcmp(curOpt, "?") == 0) {
  706.             Opt_PrintUsage (argv[0], optionArray, numOptions);
  707.             exit(0);
  708.             }
  709. d147 1
  710. a147 1
  711.                 OptNoArg(curOpt);
  712. d156 1
  713. a156 1
  714.                 OptNoArg(curOpt);
  715. d173 1
  716. a173 1
  717.                 OptNoArg(curOpt);
  718. d217 1
  719. a217 1
  720.         if (allowClustering) {
  721. @
  722.  
  723.  
  724. 1.1
  725. log
  726. @Initial revision
  727. @
  728. text
  729. @d17 1
  730. a17 1
  731. static char rcsid[] = "$Header: option.c,v 2.4 88/07/11 13:27:47 douglis Exp $ SPRITE (Berkeley)";
  732. d51 3
  733. a53 4
  734. void
  735. Opt_Parse(argcPtr, argv, numOptions, optionArray, allowClustering)
  736.     int           *argcPtr;         /* Pointer to number of arguments
  737.                      * in argv */
  738. d55 1
  739. a56 1
  740.     Option        optionArray[];    /* Array of option descriptions */
  741. d77 1
  742. a77 1
  743.     argc = *argcPtr - 1;
  744. d100 3
  745. d125 1
  746. a125 1
  747.             Opt_PrintUsage (argv[0], numOptions, optionArray);
  748. d207 1
  749. a207 1
  750.                 Opt_PrintUsage (argv[0], numOptions, optionArray);
  751. d248 1
  752. a248 1
  753.     *argcPtr = argIndex;
  754. d269 1
  755. a269 1
  756. Opt_PrintUsage(commandName, numOptions, optionArray)
  757. d271 1
  758. a272 1
  759.     Option optionArray[];
  760. d285 3
  761. d307 1
  762. a307 1
  763.             fprintf(stderr, "\t\tDefault value: %lf\n",
  764. @
  765.